Automation of information technology system development

ABSTRACT

A method and associated computer program product for developing an Information Technology (IT) system. An abstract IT structure for the IT system is provided. A virtual IT structure for the IT system is generated from the abstract IT structure by a translator. A real IT structure for the IT system is generated from the virtual IT structure.

BACKGROUND OF THE INVENTION

1. Technical Field

The present invention relates to automation of Information Technology(IT) system development.

2. Related Art

A number of activities are associated with use of a computer. Theseactivities may be grouped into several categories: development,deployment, operations and maintenance, and productive use. The categoryof development comprises determination of specific hardware, software,and networking required to satisfy the specific usage needs; planning ofa production system.

The category of deployment comprises implementation of the developedproduction system, ranging from acquisition of the appropriate hardwareand software to installation, configuration, and customization ofacquired software, hardware and network devices, to verification ofcorrectness of the built system.

The category of operations and maintenance comprises operation of thedeployed production system and introduction of changes to it.

The category of productive use comprises application of the deployedproduction system to activities for which it is intended.

The preceding categories of activities are common to computing systems,be it a stand-alone personal computer, or a geographically dispersedcollection of highly complex systems supporting an internationalcorporation. The first three of the preceding categories of activities(i.e., development, deployment, operations) are a liability required insupport of the last activity category of productive use of a computersystem. While for a single stand-alone personal computer, development,deployment and operations may involve miniscule investment of timeand/or money (with the exception of the acquisition of the necessaryhardware and software), in large institutions, these preceding threeactivities occupy armies of technical and administrative personnel andentail high costs, primarily due to complexity of computer systems,exacerbated by constantly evolving technology and business requirements.

Thus, there is a need for a method and system to reduce costs pertainingto Information Technology (IT) development.

SUMMARY OF THE INVENTION

The present invention provides a method and associated computer programproduct for developing an Information Technology (IT) system, saidmethod comprising:

providing an abstract IT structure for the system being developed;

generating a virtual IT structure from the abstract IT structure; and

generating a real IT structure from the virtual IT structure.

The present invention provides a method and associated computer programproduct for translating an instance X of an abstract InformationTechnology (IT) structure of a project to a virtual IT structure, saidmethod comprising:

translating X to an interim IT structure instance X′ that is lessabstract than is X; and

if X′ is not the virtual IT structure then repeatedly performingadditional steps X until X′ is the virtual IT structure or until saidtranslating detects an error condition, said additional steps comprisingsetting X=X′ and again performing said translating X to X′.

The present invention provides a method and associated computer programproduct for delivery binding a virtual Information Technology (IT)structure X into a delivery-bound virtual IT structure XDB, said methodcomprising:

invoking an addElement( ) method to add at least one additional ITstructure A to the composition of X to form a primitive composition ofXDB;

assigning a name to each element of the primitive composition of XDB;and

if at least one element of the primitive composition of XDB requiresaccess to the Internet then assigning an IP address to the at least oneelement of the primitive composition of XDB.

The present invention provides a method and associated computer programproduct for reverse-specifying at least one Information Technology (IT)structure, said method comprising:

providing information relating to an IT entity selected from the groupconsisting of an IT delivery environment and an IT system instance; and

generating a real IT structure from the information relating to the ITentity.

The present invention provides a method and associated computer programproduct for adding an Information Technology (IT) structure A to an ITstructure X, said method comprising:

first determining whether adding A to X violates any dependency of X andaborting if said first determining determines that adding A to Xviolates said any dependency of X;

second determining whether adding A to X violates any dependency of Aand aborting if said second determining determines that adding A to Xviolates said any dependency of A; and

adding A to X if said first determining and said second determiningdetermines that adding A to X does not violates any dependency of X andA, respectively.

The present invention provides a method and associated computer programproduct for comparing an Information Technology (IT) structure instanceX with IT structure Y, said method comprising matching elements of X andY and/or matching relationships of X and Y,

said matching elements of X and Y comprising matching the elements of aprimitive composition XC of X to the elements of a primitive compositionYC of Y to determine whether an element mismatch exists, wherein saidelement mismatch exists if at least one element of XC does not exist inYC or at least one element of YC does not exist in XC, and if saidmatching the elements determines that said element mismatch exists thendetermining any elements of XC existing in YC and any elements of YC notexisting in XC; and

said matching relationships of X and Y comprising matching therelationships XR of X to the relationships YR of Y to determine whethera relationship mismatch exists, wherein said relationship mismatchexists if at least one relationship of XR does not exist in Y or atleast one relationship of YR does not exist in X, and if said matchingthe relationships determines that said relationship mismatch exists thendetermining any relationships of XR existing in Y and any relationshipsof YR not existing in X.

The present invention provides a method and associated computer programproduct for deleting an Information Technology (IT) structure A from anIT structure X, said method comprising:

determining a composition C of X;

generating a list of relationships R of the elements of C that involveA;

generating a list of dependencies D of the elements of C on A, excludingany dependency of A on A;

if a <force> option was selected then removing A from C; and

if the <force> option was not selected and (R is not null or (D is notnull and D is not null and a replacement IT structure in C satisfyingeach dependency in D has not been found)) then exiting without removingA from C, else removing A from C.

The present invention advantageously provides a method and system toreduce costs pertaining to Information Technology (IT) systemdevelopment.

BRIEF DESCRIPTION OF THE DRAWINGS

FIG. 1 is a diagram illustrating Information Technology (IT) entitiesincluded in the base entity model, and organized in a class hierarchy,in accordance with embodiments of the present invention.

FIG. 2 is a flow chart depicting the logic of setRelationship( ) method,in accordance with embodiments of the present invention.

FIG. 3 is a flow chart depicting the logic of addElement( ) method, inaccordance with embodiments of the present invention.

FIG. 4 is a flow chart depicting the logic of deleteElement( ) method,in accordance with embodiments of the present invention.

FIG. 5 is a flow chart, depicting the logic of setAvailable( ) method,in accordance with embodiments of the present invention.

FIG. 6 is a flow chart depicting the logic of establishInterface( )method, in accordance with embodiments of the present invention.

FIG. 7 is a flow chart depicting the logic of ensureDependencies( )method, in accordance with embodiments of the present invention.

FIG. 8 is a diagram illustrating the concept of IT structurecomposition, in accordance with embodiments of the present invention.

FIG. 9 is a chart depicting the IT development process, in accordancewith embodiments of the present invention.

FIG. 10 is a flow chart depicting the process of translation of an ITstructure instance, in accordance with embodiments of the presentinvention.

FIG. 11 is a flow chart depicting the translation iteration process, inaccordance with embodiments of the present invention.

FIG. 12 is a flow chart depicting the process of ensuring specificationof characteristics of an abstract IT structure instance, in accordancewith embodiments of the present invention.

FIG. 13 is a flow chart depicting the process of adjusting a particularset of characteristics of an IT structure instance, in accordance withembodiments of the present invention.

FIG. 14 is a flow chart depicting the process of selection a subclass ofan IT structure, in accordance with embodiments of the presentinvention.

FIG. 15 is a flow chart depicting the process of selecting the besttranslation candidate from a list of translation candidates, inaccordance with embodiments of the present invention.

FIG. 16 is a flow chart depicting a reverse specification process, inaccordance with embodiments of the present invention.

FIG. 17 is a flow chart depicting a process for comparing two ITstructure instances, in accordance with embodiments of the presentinvention.

FIG. 18 is an extended class hierarchy example, in accordance withembodiments of the present invention.

FIG. 19 is a flow chart for implementing delivery binding of an ITstructure to a delivery environment, in accordance with embodiments ofthe present invention.

FIG. 20 illustrates a computer system used for implementing an IT EntityModel and associated processes, in accordance with embodiments of thepresent invention.

DETAILED DESCRIPTION OF THE INVENTION

The detailed description of the present invention is organized into thefollowing sections:

-   1. Nomenclature;-   2. Information Technology (IT) Entity Model (defines basic IT    entities and describes their properties and associated processes);-   3. Computer System (describes computer system used to implement an    IT Entity Model and associated processes)    1. Nomenclature    1.1 Flow Charts

The flow charts in the Figures comprise, inter alia, the following blockshapes:

-   1) Rectangular: represents execution of code as described (e.g.,    FIG. 3, block 2202); and-   2) Diamond: represents a decision block (e.g., FIG. 3, block 2203).    1.2 Abbreviations

The following abbreviations are utilized herein.

-   CASE—computer-aided software engineering-   CICS—Customer Information Control System-   CPU—central processor unit-   DASD—direct access storage device-   DB—database-   DNS—domain name server-   GB—gigabyte-   GUI—graphical user interface-   HTTP—HyperText Transfer Protocol-   HTTPS—HTTP Secure-   IDE—integrated development environment-   IP—internet protocol-   IT—information technology-   KB—kilobyte-   KW—kilowatt-   LAN—local-area network-   LOC—lines of code-   Mbps—megabits per second-   MHz—mega-Hertz-   MP—multi-processor-   NIC—network interface card-   NOOP—no operation (moot)-   OS—operating system-   PM—person/month-   POTS—“plain old telephone service”-   RAM—random-access memory-   RISC—reduced instruction set computer-   SL—service level-   SMTP—Simple Mail Transfer Protocol-   S/N—serial number-   TCO—total cost of ownership-   TCP/IP—transmission control protocol/internet protocol-   UI—user interface-   UML—universal modeling language-   UP—uni-processor-   UPS—uninterruptible power supply    2. Information Technology (IT) Entity Model

IT systems and environments may be described in terms of IT entities.The term “entity” is understood to denote “IT entity” herein.

The base entity model comprises IT entities, relationships among the ITentities, and interfaces and methods provided by these IT entities.

For illustrative purposes, Java-like syntax is used herein as aspecification language for IT structures. An IT structure is a set of ITentities. Generally, another programming language (e.g., objectoriented, procedural, high- or low-level) maybe used instead of Java; amodeling language (e.g., UML) may be used instead of Java; and aspecialized language could be defined and implemented solely for thepurpose of definition of IT structures.

2.1 IT Entities

FIG. 1 is a diagram illustrating IT entities included in the base entitymodel, and organized in a class hierarchy as shown in Table 1, inaccordance with embodiments of the present invention.

TABLE 1 ITEntity 2001 ITStructure 2003 ITDeliveryEnvironment 2007ITInterface 2005 defaultInterface 2022 InstalledOn 2015 Supports 2016Invokes 2017 Invokable 2018 ConnectsTo 2019 Manages 2020 Mangeable 2021ITRelationship 2004 DefaultITRelationship 2010InstallationITRelationship 2011 InvocationITRelationship 2012CommunicationITRelationship 2013 ManagementITRelationship 2014ITDependency 2006 RequiresPresenceOf 2008 ExclusiveWith 2009

IT entities may be qualified as real, virtual, or abstract. A real ITentity has no undefined characteristic and may therefore be representedphysically. A virtual IT entity has exactly one undefined characteristicand thus cannot have more than one undefined characteristic. An abstractIT entity has at least two undefined characteristics. Examples of realentities, virtual entities, and abstract entities will be presentedinfra. For convenience, class Type is introduced as follows:

-   -   Enumeration Type:=(abstract, virtual, real)        2.1.1 ITEntity Class

ITEntity class is introduced for convenience as a root class for theother IT entity classes listed above. ITEntity has the followingmethods:

-   1) constructor(String name [, Type type])—creates an instance of    ITEntity with the specified name and of optionally specified type-   2) boolean isAbstract( ), returns true if ITEntity is abstract,    false otherwise-   3) boolean isVirtual( ), returns true if ITEntity is virtual, false    otherwise-   4) boolean isReal( ), returns true if ITEntity is real, false    otherwise-   5) getName( )—returns ITEntity name-   6) setType(Type type)—changes IT entity type as specified    2.2 IT Structures

An IT structure is either a primitive IT structure or a complex ITstructure.

A primitive IT structure is an IT entity representing materials orlabor, indivisible within a particular view to a structural model, and aset of method associated with characteristics of the representedmaterials or labor.

A real primitive IT structure represents a specific single physicalobject or a specific unit of labor. Examples of real primitive ITstructure include:

-   1) RS/6000 model F50 S/N 123456-AB. There is one and only one    RS/6000 model F50 with this particular S/N.-   2) Software product Ppppp version vvvvv license key    12345678-AB-9ABCD-XYZ.

A virtual primitive IT structure represents a class of specific physicalobjects. Examples of virtual primitive IT structure include:

-   1) RS/6000 model F50. Since no s/n is specified, there is a class of    RS/6000 model F50 this virtual primitive IT structure corresponds    to, and RS/6000 model F50 with any s/n belongs to this class.-   2) Software product Ppppp version vvvvv.

An abstract primitive IT structure represents an abstract view ofmaterials or labor. In this embodiment, abstract primitive IT structuresinclude the same out-of-model IT entity, called abstractPrimitive. Otherembodiment may have a multiplicity of abstract primitive out-of-modelentities. Examples of abstract primitive IT structure include:

-   1) RS/6000. Since no model is specified, any RS/6000, including    model F50, as well as any other models, belongs to this class.-   2) Computer. Since no architecture, type, or any other    characteristics are specified, any computer, including any model of    RS/6000, belongs to this class.-   3) Software product Ppppp.-   4) Software product.

Primitive IT structures are indivisible only within a particular model.For example, a computer may be viewed as indivisible in the context ofthe model used in this embodiment. In a different embodiment, however, adifferent model may exist in which a computer may be represented as anIT structure (see discussion infra of a complex IT structure),comprising several primitive IT structures; e.g., the followingcollection of primitive IT structures: processor, memory, DASD, andnetwork interface.

A complex IT structure is a non-empty collection of IT structures, adefined set of relationships (see below) among these IT structures, anda description of this IT structure's characteristics. Examples of acomplex primitive IT structure include:

-   1) a personal computer-   2) a network of Lotus Domino servers-   3) a zSeries sysplex-   4) a collection of programs running on a particular computer-   5) a collection of software and hardware required to run Ariba Buyer    application-   6) a hosted application service-   7) a professional service

In the process of formation of an IT structure, values of properties ofelements of this IT structure's composition (see below) may change;e.g., assignment of a name to a computer may be required to include thatcomputer in an IT structure.

The set of relationships is imposed by a particular IT structure, ratherthan being intrinsic for the primitive IT structures comprising the ITstructure. Thus, multiple complex IT structures may be created from thesame set of primitive IT structures, and uniqueness of the assigned name(i.e., its inequality to any other computer name) may be imposed on aprimitive IT structure representing a computer, included in a complex ITstructure.

An IT structure composition is the list of IT structures included in acomplex IT structure, or an out-of-model entity describing the entityrepresented by a primitive IT structure (e.g., a String, or a referenceto a DB record).

An IT structure composition element is an IT entity included in an ITstructure composition.

An IT structure primitive composition is the list of primitive ITstructures included in an IT structure, where all complex IT structuresare replaced with their respective primitive compositions.

FIG. 8 is a diagram illustrating the concept of IT structurecomposition, in accordance with embodiments of the present invention. Acomplex IT structure A 2701 includes in its composition 2703 two othercomplex IT structures B 2704 and C 2705, and one abstract primitive ITstructure D 2706. Complex IT structure B includes in its composition twoprimitive IT structures E 2708 and F 2709, and complex IT structure Cincludes in its composition two primitive IT structures, an abstractprimitive IT structure G 2710, and a primitive IT structure H 2711. Bothabstract primitive IT structures, D and H, represent theabstractPrimitive out-of-model entity 2712, while all other primitive ITstructures represent respective non-abstract out-of-model entities 2713,2714, 2715. The IT structure A primitive composition 2707 includes allprimitive IT structures shown (and no complex IT structures), namelyprimitive IT structures E 2708, F 2709, G 2710, H 2711, and D 2706.

An abstract IT structure is an IT structure whose composition includesat least one abstract IT entity. Examples of an abstract IT structureinclude:

-   1) An abstract IT structure may include an Intel computer with a    single 400 MHz Pentium processor, 1024 MB of main memory, 10 GB of    DASD, and an Ethernet network interface; however, since no    particular model of computer is specified, this IT structure would    be abstract.-   2) At a different (higher) level of abstraction, the same IT    structure may include just a computer, without specification of its    technology or characteristics.

A virtual IT structure is a non-abstract IT structure whose compositionincludes at least one virtual IT entity.

A real IT structure is a non-abstract and non-virtual IT structure.

From the above definitions, it follows that a real IT structure onlyincludes real IT entities in its composition. From the abovedefinitions, it also follows that in a real IT structure, each IT entityin its composition uniquely corresponds to a physical IT entity.

Table 2 infra provides examples of IT structure composition.

TABLE 2 Examples of IT structure composition IT structure NetworkingComputers Software Labor Abstract IT network computer Ariba Buyerstructure with application high degree of abstraction Abstract IT TCP/IPplatform Ariba Buyer structure with network Application low degree of v7abstraction Virtual IT connectivity platform and Ariba Buyerinstallation structure requirements associated v7 for and parameters AIXon management (memory, RS/6000 processor power, DASD space) Delivery-LAN model Ariba Buyer specific bound IT segments v7.02 for installationstructure with AIX on activities; symbolic IP RS/6000 specific addressesmanagement activities Real IT LAN computer s/n Ariba Buyer skill levelstructure segments specified v7.02 for and with AIX on quantity real IPRS/6000, of labor addresses license # by activity <lic. #> specified

An abstract IT structure with a high level of abstraction may be “anAriba Buyer application running on a computer, connected to a network”.The degree of abstraction can be lowered by restating the previousclause in more specific terms—“an Ariba Buyer application running on anRS/6000 computer, connected to a TCP/IP network”.

The corresponding virtual IT structure may be “an Ariba Buyer version7.0 for AIX on RS/6000 application, running on an AIX v5.0 operatingsystem and RS/6000 model F50 computer with one 320 MHz CPU, 640 KB ofmain memory, and 128 GB of DASD in a single disk, connected through a 10Gbps Ethernet LAN to a TCP/IP network—and—labor associated withinstallation and management of the above”.

Once resolved into a delivery-bound IT structure, the previous ITstructure may turn into something like “an Ariba Buyer version 7.0 pathlevel 17.2 for AIX on RS/6000 application, running on an AIX v5.0 patchlevel 5.0.3.2 operating system and RS/6000 model F50-3745 computer withone 320 MHz CPU, 640 KB of main memory, 128 GB of DASD in a single disk,and a NIC (network interface card), connected through a 10 Gbps EthernetLAN to a TCP/IP network on a single segment with a symbolic IP addressof a.b.c.d and specific installation and management activitiesassociated with the above.

Once deployed in a data center, the corresponding real IT structurewould be “an Ariba Buyer version 7.0 path level 17.2 for AIX on RS/6000application, license # 178215-04, running on an AIX v5.0 patch level5.0.3.2 operating system, license #514ABC-AE, and RS/6000 model F50-3745computer, s/n 6734-FWU, with one 320 MHz CPU, 640 KB of main memory, 128GB of DASD in a single disk, and a NIC (network interface card),connected through a 10 Gbps Ethernet LAN to a TCP/IP network on a singlesegment with a symbolic IP address of a.b.c.d and specific installationand management activities associated with the above, including quantityof labor and level of skills for each.

A delivery-bound IT structure is a virtual IT structure ready forprovisioning in a particular delivery environment (see below) with noadditional input/sources of information. “In a particular deliveryenvironment” means “at the level of detail required by the provisioningprocess of the delivery environment”. For example, a delivery-bound ITstructure may include a specification of 10/100 Mbps Ethernet card,without regard to the manufacturer of that card.

An operating IT structure instance is a collection of physical hardware,software, networking, and labor, resulting from deployment of a real ITstructure.

2.2.1 ITStructure Class

An IT Structure is represented by a class ITStructure, which inheritsfrom ITEntity class and has the following methods:

-   1) ITStructure(String name, String function, Vector functions,    Vector operationalCharacteristics)—constructor-   Note: Type is not specified for an ITStructure class—it is always    derived based on ITStructure composition using the type definition    as a rule.-   2) Vector getFunctions( )—returns a list of functions (String)    supported by ITStructure (always non-null)-   3) Vector setFunctions(Vector V)—adjusts IT structure for support of    one or more functions whose names were previously returned by    getFunction( ) method; the list V is a list of pairs    (<function>,<value>), where <function> is one of the list returned    by getFunction( ) method and <value> is the associated setting. The    method returns an empty Vector if the method execution was    successful, and a list of error messages otherwise. If an error    occurs, the method has not altered the IT structure.-   4) Vector getOperationalCharacteristics( )—returns a list of pairs    of names (String) and values (String) of operational characteristics    of this IT structure-   5) Vector setOperationalCharacteristics(Vector V)—adjusts IT    structure operational characteristics as specified by the input    parameters. The input parameter is a list of pairs of (operational    characteristic name (String), characteristic value), where    operational characteristic name is one of the values returned by the    getOperaitonalCharacteristics( ) method, and characteristic value is    specific to the operational characteristic being modified. The list    V corresponds to all of or a subset of the list returned by    getOperationalCharacteristics( ) method. The method returns an empty    Vector if the method execution was successful, and a list of error    messages otherwise. If an error occurs, the method has not altered    the IT structure.-   6) Vector getResolutionValues( )—returns a list of pairs of names    (String) and values (String) of abstraction resolution parameters of    this IT structure-   7) JavaClass resolve(Vector V), where V is Vector of pairs (String    resolution_parameter, value)—returns a less abstract ITStructure    instance, instantiated with the specified resolution parameters if    execution was successful; returns a Vector of error messages if no    resolution was possible (in which case the IT structure is left    unmodified)-   8) boolean isPrimitive( )—returns true if this IT structure is    primitive-   9) boolean isComplex( )—returns true if this IT structure is complex-   10) Vector getComposition( )—for a complex IT structure, returns    list of other IT structures comprising this IT structure; for a    primitive IT structure, returns the list including the IT structure    itself.-   11) Vector getPrimitiveComposition( )—returns primitive composition    of an IT; returns the IT structure itself if invoked for a primitive    IT structure.-   12) Vector getInterfaces( )—returns the list of IT interfaces this    IT structure possesses-   13) Vector getRelationships( )—returns a list of IT relationships    elements of this IT structure's composition are involved in; returns    an empty Vector if no IT relationships exist among elements of this    IT structure's composition.-   14) Vector getPrimitiveRelationships( )—returns a list of IT    relationships elements of this IT structure's primitive composition    are involved in; returns an empty Vector if no IT relationships    exist among elements of primitive composition of this IT structure.-   15) ITRelationship getRelationship(ITStructure A, ITStructure    B)—returns the ITRelationship instance for relationship of IT    structures A and B within the composition of this IT structure or    null if IT structures A and B are not involved in an IT relationship-   16) Vector setRelationship(ITStructure x, ITInterface xi,    ITStructure y, ITInterface yi, Relationship r)—establishes the    relationship r between IT structures x and y within the composition    of this IT structure. Returns a null Vector if relationship was    established successfully, and a Vector of error messages if    relationship could not be established.-   17) Vector setDependency({<add>|<remove>}, ITDependency x)—adds or    removes the specified IT dependency to or from this IT structure.    Returns a null Vector if dependency was added or removed    successfully, and a Vector of error messages if dependency could not    be added. Removal of an IT dependency is always successful. Addition    of an IT dependency may fail if x contradicts an existing    dependency—e.g., x indicates mutual exclusivity with IT structure Y    and a dependency on presence of Y is already stated.-   18) Vector getDependencies( )—returns a list of IT dependencies of    this IT structure.-   19) Vector addElement(ITStructure A)—adds IT structure A to the    composition of this IT structure. Returns a null Vector if addition    was successful, and a Vector of error messages if addition failed.    In order to ensure uniqueness of identifiers (computer names,    network addresses) within IT structures, each identifier within IT    structure A being added is prefixed with string A.getName( )+“.”. As    a part of the addition process, addElement( ) method verifies that:

a. addition of IT structure A to the composition of this IT structuredoes not violate any IT dependencies for any IT structure alreadyincluded in the composition of this IT structure

b. addition of IT structure A to the composition of this IT structuredoes not violate any IT dependencies for IT structure A

and ensures that IT dependencies of the IT structure being added aresatisfied. Each added IT structure composition element's name isprefixed with the IT structure name to ensure uniqueness.

-   20) Vector ensureDependencies(ITStructure A)—ensures that IT    dependencies of the class requiresPresenceOf of ITStructure A in the    composition of this IT structure are satisfied. If processing is    unsuccessful, a Vector of error message(s) is returned, otherwise, a    null Vector is returned.-   21) Vector deleteElement(ITStructure A [, <force>])—removes IT    structure A from the composition of this IT structure. Returns a    null Vector if removal was successful, and a Vector of error    messages if removal failed. <force> indicates that A should be    removed regardless of relationships with or dependencies on it by    other elements of this IT structure's composition.-   22) Vector setOptimizationFunctions(Vector F)—specifies a    prioritized list (starting with the highest priority and ending with    the lowest) of optimization classes (see Optimization) to be applied    to this IT structure. Returns a null Vector if processing is    successful, and a Vector of error messages otherwise.-   23) Vector getOptimizationFunctions( )—returns the prioritized list    of optimization classes to be applied to this IT structure.-   24) Vector optimize( )—performs optimization of the IT structure    using the specified prioritized list of optimization classes and    applying each optimization function to the IT structure in turn,    starting with the highest and ending with the lowest priority of    optimization classes. Returns a Vector, containing the optimized IT    structure as its first element if optimization was successful, and a    list of error messages otherwise.-   25) Vector setTargetITDeliveryEnvironments(Vector D)—specifies a    list of target IT delivery environments (see below) for this IT    structure. Returns a list of error messages if an error occurs    (e.g., invalid specification of a target IT delivery environment),    and a null Vector otherwise.-   26) Vector getTargetITDeliveryEnvironments( )—returns the list of    target IT delivery environments for this IT structure.-   27) getID( )—returns a real IT structure's unique identifier;    returns null if invoked for a non-real IT structure.-   28) setID( )—sets real IT structure unique identifier; NOOP for a    non-real IT structure.-   29) Vector SLmaintenance(Vector V)—optional, supported for Autonomic    IT System Improvement Cycle (see below); obtains a list of pairs of    operational characteristics and associated values provided by    monitoring facilities, and performs adjustment of the operational    characteristics to sustain the SL. Returns a null Vector if    processing is successful and a list of error messages if processing    is unsuccessful.    2.2.2 Detailed Description of Non-Trivial Methods    2.2.2.1 SetFunctions

A composition of an IT structure instance and relationships amongelements of its composition may depend on particular function(s) this ITstructure instance is intended to perform. The purpose of this method isto perform the necessary adjustments within IT structure instance thattailor IT structure composition and relationships among composition'selements as appropriate. This method also performs enforcement offunction-specific rules.

The setFunctions( ) method is subclass-specific. Class ITStructureincludes a placeholder that does nothing other than store the specifiedbusiness function. ITStructure examples include:

-   1) IT structure X has three functions—A, B, C. However, these    functions cannot be fulfilled indiscriminately (by their    nature)—either A, or B and/or C, but not A and B, A and C, or A, B,    and C can be supported by any instance of IT structure X. The    setFunctions( ) method, when invoked, would ensure proper    combination of functions requested from the instance of X, and    prohibit improper modifications in the future.-   2) Composition of instance of X may depend on the functions it    performs. To perform function A, X may need to include an Intel    server running Windows OS, an Oracle DB and a specific program    package supporting function A. To perform functions B or C, X may    need to include an RS/6000 server (whose power depends on whether    only one of functions B and C, or both of these functions are    supported), with a DB2 DB and specific program packages supporting    functions B or C. So, the composition of X will be altered by the    setFunctions( ) method appropriately, based on specification of    functions.    2.2.2.2 SetOperational Characteristics

A composition of an IT structure instance and relationships amongelements of its composition, given a particular set of functionssupported by the IT structure instance, may depend on operationalcharacteristics associated with support of particular functions. Thepurpose of this method is to perform the necessary adjustments within ITstructure instance that tailor IT structure composition andrelationships among composition's elements as appropriate. This methodalso performs enforcement of operational-characteristic-specific rules.

The setOperationalCharacteristics( ) method is subclass-specific. ClassITStructure includes a placeholder that does nothing other than storethe specified operational characteristic values.

EXAMPLES

-   1) IT structure X function A potentially supports up to 500 users.    Its response time depends on the power and amount of memory of the    processor that runs function A and an increment in the number of    supported users can be translated into a processor power and memory    increments. An instance of X is created, whose requirement is to    support up to 200 users. setOperationalCharacteristics(new    Vector(“users”, 200)) can be used to specify that number and adjust    the configuration of the Intel server supporting function A in the    composition of instance of X to ensure it supports the required    number of users.-   2) Availability of IT structure X instance supporting function A may    be 80% or 99.8%, depending on configuration of processors and    software supporting function A. If a single set of hardware and    software elements support function A, availability is 80%; if    supporting hardware and software are duplicated and appropriate    monitoring software is added to permit takeover between the two sets    of hardware and software, availability is 99.8%.    setOperationalCharacteristics(new Vector(“availability”, “high”))    can be used to indicate that instance of X when supporting function    A must provide. 99.8% availability.-   3) The above operational characteristics settings may be combined:    setOperationalCharacteristics(new Vector((“users”, 200),    (“availability”, “high”)))    2.2.2.3 Resolve

A composition of an IT structure instance and relationships amongelements of its composition, given a particular set of functionssupported by the IT structure instance and given a particular set ofoperational characteristics associated with support of the particularset of functions, may depend on additional factors. A purpose of thismethod is to perform the necessary adjustments within IT structureinstance that tailor IT structure composition and relationships amongcomposition's elements as appropriate.

The resolve( ) method is subclass-specific. Class ITStructure includes aplaceholder that does nothing other than store the specified resolutionvalues.

Example

Two hardware and operating systems platforms exist that provideequivalent (both in terms of scale and cost) performance, permitting aninstance of IT structure X to support the required number of users withequivalent operational characteristics for its function A. For example,the choice of either of the two hardware and operating system platformsfor the composition of an instance of IT structure X providing functionA will produce an equivalent result. Further, the delivery environmentin which the instance of X will operate, support both combinations ofhardware and operating system with equivalent costs and service levels.The resolve( ) method may be used to specify which of the twocombinations of hardware and operating system platforms to use based onother factors. For example, IT developer's preference or similarity withhardware and operating system platforms of other IT structures involvedin a solution.

Assume the two combinations of hardware and operating system platformsare (a) AIX on RS/6000 and (b) Linux on Intel. So, IT structure X mayprovide a resolution characteristic “platform preference” which may bespecified as “AIX” or “Linux”, resulting in the choice of (a) or (b) forthe instance of IT structure X.

2.2.2.4 setRelationship

Once an IT structure is added to the composition of the IT structurebeing developed, the developer may specify IT relationships between theadded IT structure and other elements of the composition or primitivecomposition of the IT structure being developed.

FIG. 2 is a flow chart depicting the logic of setRelationship( ) method,in accordance with embodiments of the present invention. The VectorsetRelationship(ITStructure x, ITInterface xi, ITStructure y,ITInterface yi, Relationship r) establishes the relationship r betweenIT structures x and y within the composition of this IT structure. ThesetRelationship( ) method returns a null Vector if relationship wasestablished successfully, and a Vector of error messages if relationshipcould not be established. The setRelationship( ) method for ITStructureinstance X is invoked with parameters ITStructure A, ITInterface AI,ITStructure B, ITInterface BI, ITRelationship R 2101. The methodattempts to find IT structure A in the composition of X 2102. If ITstructure A is not found in the composition of X 2103, an error messageis returned 2104 and processing terminates. The method then attempts tofind IT structure B in the composition of X 2105. If IT structure B isnot found in the composition of X 2106, an error message is returned2107 and processing terminates. The method then proceeds to finding ITinterface AI in the list of IT interfaces of IT structure instance A2108. If AI is not found 2109, an error message is returned 2110 andprocessing terminates. The method then attempts to find IT interface BIin the list of IT interfaces of IT structure instance B 2111. If BI isnot found 2112, an error message is returned 2113 and processingterminates.

Upon ascertaining presence of both specified IT structure instances Aand B and IT interfaces AI and BI within A and B, the method executionenters a critical section 2114 which is used to serialize updates to theIT interface states. A critical section is a portion of the method whichcannot be executed concurrently in a multi-threaded fashion, and entryto which must be serialized. No particular method of serialization forcritical sections of programs is prescribed by this embodiment—knownmethods include (but are not limited to) semaphores, process queues,process locks, TS (Test and Set) instruction, CS (Compare and Swap)instruction.

The method then checks availability of IT interface AI by invoking thegetAvailable( ) method of IT interface AI; if AI is unavailable 2115, anerror message is returned 2116, previously entered critical section isexited 2124, and processing terminates. The method proceeds to checkingavailability of IT interface BI by invoking the getAvailable( ) methodof IT interface BI; if BI is unavailable 2117, an error message isreturned 2118, previously entered critical section is exited 2124, andprocessing terminates.

Upon ascertaining availability of both AI and BI interfaces, the methodattempts to relate IT interfaces AI and BI. Vector x is allocated (notshown in the figure) to contain error message strings from attempts toestablish the interface between AI and BI. The method attempts to updateIT interface AI as interfacing with IT interface BI by invoking AImethod establishInterface(BI), passing it BI as the parameter 2119. Ifan error occurs during the establishInterface(BI) method of AIinvocation 2120, Vector x contains error messages, which are returned tothe invoker of setRelationship( ) method of IT structure instance X 2121upon exiting the critical section 2124. The method then attempts toupdate IT interface BI as interfacing with IT interface AI by invokingBI method establishInterface(AI), passing it AI as the parameter 2122.If an error occurs during the establishInterface(BI) method of AIinvocation 2123, Vector x contains error messages, which are returned tothe invoker of setRelationship( ) method of IT structure instance X 2121upon exiting the critical section 2124, but only after the error cleanupis performed and the previously established update of IT interface AI isreversed by invoking its method setAvailable(BI) 2125.

If interface establishment was successful, IT relationship R is updatedto contain the interface AI and BI 2125 prior to completion of methodexecution.

2.2.2.5 Addelement

FIG. 3 is a flow chart depicting the logic of addElement( ) method, inaccordance with embodiments of the present invention. The VectoraddElement(ITStructure A) method adds IT structure A to the compositionof IT structure X. The IT structures A and X may each independently bean abstract IT structure, a virtual IT structure, or a real ITstructure. However, the resulting IT structure will have the highestdegree of abstraction of that of X and A. For example, if X is abstractthe result will be abstract even if A is not abstract, and if A isabstract the result will be abstract even if X is not abstract. Asanother example, if either X or A is virtual, and both X and A are notabstract, the result will be virtual.

The addElement( ) method returns a null Vector if addition wassuccessful, and a Vector of error messages if addition failed. TheaddElement( ) method of ITStructure instance X is invoked with parameterITStructure A, referencing the ITStructure instance to be added to X'scomposition 2201. The method retrieves composition of X as a Vector C2202. If C is null (there are no composition elements for X) 2203, thisis the addition of the first element, and no additional checks arenecessary. The method creates a composition Vector C for X 2204, addsITStructure A to C 2205, and returns.

If ITStructure X is a primitive IT structure (X.isPrimitive( )=true)2243, an error message is stored 2244 and processing terminates.

If ITStructure X already has non-empty composition 2203, the methoditerates through X's composition elements making sure no IT dependenciesof either X or A are violated by the addition of A to X. While there areelements in C 2206, the next unprocessed element E of C is obtained2207, and its list of IT dependencies De is extracted using thegetDependencies( ) method of E 2208.

While there are unprocessed elements in De (list of IT dependencies ofITStructure E) 2209, the following is performed. A critical section isentered 2210. The next element d of De is obtained 2211. If d (whichbelongs to the class ITDependency) indicates exclusion with class Y andIT structure A belongs to class Y or its subclass 2212, an error messageis stored 2213, and upon exiting from the critical section 2214,processing terminates. Otherwise, critical section is exited 2215.

The method execution then proceeds to obtaining the list Da of ITdependencies of A using the getDependencies( ) method of A 2216. Whilethere are unprocessed elements in Da (list of IT dependencies ofITStructure A) 2217, the following is performed. A critical section isentered 2218. The next element d of Da is obtained 2219. If d (whichbelongs to the class ITDependency) indicates exclusion with class Z andIT structure E belongs to class Z or its subclass 2220, an error messageis stored 2213, and upon exiting from the critical section 2214,processing terminates. Otherwise, critical section is exited 2222.

When all possible combinations of potential dependencies of IT structureA and all elements of the composition of X are exhausted, and noviolation has been found, the addElement( ) method invokes methodensureDependencies(A) 2245 to ensure that any of A's IT dependencies ofthe class requiresPresenceOf are satisfied. If ensureDependencies( )method's processing was not successful 2246, any error messages returnedby the ensureDependencies( ) method's invocation are returned,otherwise, A is added to the composition A is added to the composition Cof IT structure X 2205.

2.2.2.6 EnsureDependencies

FIG. 7 is a flow chart depicting the logic of ensureDependencies( )method, in accordance with embodiments of the present invention. TheensureDependencies(ITStructure A) method ensures that IT dependencies ofthe class requiresPresenceOf of ITStructure A in the composition of thisIT structure are satisfied. If processing is unsuccessful, a Vector oferror message(s) is returned, otherwise, a null Vector is returned. TheensureDependencies( ) method is invoked for IT structure instance X withparameter ITStructure A 2601. The method retrieves composition of X asVector C 2602 and the list of A's IT dependencies, from which it selectsa subset (list D) of IT dependencies of class requiresPresenceOf 2603.The method then iterates through list D of IT dependencies of classrequiresPresenceOf of IT structure A, until the end of the list isreached 2604. Each element d of list D is an IT dependency d of classrequiresPresenceOf. The method retrieves the next element d from thelist 2605 and attempts to find an element of C (IT structure Xcomposition) that satisfies the IT dependency d 2606. If an element E ofC satisfying IT dependency d is found 2607, IT dependency d isconsidered to be satisfied.

ensureDependencies( ) method then creates an abstract IT structure E ofITStructure subclass that satisfies IT dependency d 2608 and attempts toadd E to the composition of IT structure X using a recursive invocationof X.addElement(E) 2609. If execution of X.addElement(E) failed (i.e., Ecould not be added to X's composition—e.g., because it is exclusive withsome element of X's composition) 2610, any error messages returned byX.addElement(E) are returned 2611 and processing terminates. Otherwise,addition of E to X's composition was successful, IT dependency d is nowconsidered to be satisfied.

An abstract IT relationship (defaultRelationship) between E (eitherfound in the composition C of IT structure X, or newly created) and Ausing defaultInterface of both is created and added to IT structure X)2612. If establishment of the IT relationship was unsuccessful 2613,error message(s) are returned to the invoker 2611. If E was newly added2614, it is removed 2615 to maintain the composition of IT structure Xunchanged.

If establishment of the new IT relationship was successful 2613, thenext element d of A's dependencies is considered.

2.2.2.7 DeleteElement

FIG. 4 is a flow chart depicting the logic of deleteElement( ) method,in accordance with embodiments of the present invention. ThedeleteElement(ITStructure A [, <force>]) method removes IT structure Afrom the composition of this IT structure. Returns a null Vector ifremoval was successful, and a Vector of error messages if removalfailed. <force>indicates that A should be removed regardless ofrelationships with or dependencies on it by other elements of this ITstructure's composition. In a first embodiment the <force> option isavailable for being selected, and in a second embodiment the <force>option is not available for being selected. Thus, the <force> option maynot be specified because: (1) the <force> option is not available forbeing selected or (2) the <force> option is available for being selectedbut was not selected. The deleteElement( ) method is invoked for ITstructure instance X with parameter ITStructure A and an optionalspecification of<force> 2301. The method retrieves composition of X asVector C 2302 and attempts to find IT structure A in C 2303. If A is notfound in C 2304, an error message is stored 2305 and processingterminates. Otherwise, the method proceeds through the attempt to removeA from C.

The method builds the list R of IT relationships of elements of C thatinvolve A 2306. If R is not null (i.e., A is involved in ITrelationships with at least one other element of composition of X) 2307,the method checks whether the <force> option was specified 2308, and ifnot, A cannot be removed from the composition of X, an error message isstored 2309, and processing terminates. If, however, <force> wasspecified, the method removes all IT relationships in the list R andremoves them from the list of IT relationships of elements of C 2310.

The method then proceeds to check IT dependencies involving A. Themethod builds a list D of all dependencies of elements of C other than Aitself on A 2311. If the list D is not null 2312, for each dependency inlist D, the method attempts to find an element in C other than A thatwould satisfy the dependency 2316. If replacements were not found forany dependencies in list D 2317, the method checks whether the <force>option was specified 2313, and if not, A cannot be removed from thecomposition of X, an error message is stored 2314, and processingterminates.

Otherwise, if all previous checks indicate that removal of A will notdamage IT structure X, or if the <force> option specification overridesthe possible damage, the method removes A from C 2315.

2.3 IT Interfaces

An IT Interface is a characteristic of an IT structure, specifying atype of relationship this IT structure can engage in relative to otherIT structures.

An abstract IT interface instance is an IT interface instance involvingat least one abstract IT structure.

A virtual IT interface instance is a non-abstract IT interface instanceinvolving at least one virtual IT structure.

A real IT interface instance is an IT interface instance involving onlyreal IT structures.

A multi-connection IT interface is an IT interface to which multiple ITstructures can relate (connect). For example, multiple invokers can calla single program—sometimes, concurrently.

A single-connection IT interface is an IT interface to which a single ITstructure can relate (connect). For example, only a single cable can beplugged into a single printer port of a personal computer.

An available IT interface is an IT interface to which one or more ITstructures can relate (connect).

A busy or Unavailable IT interface is an IT interface which hasexhausted its ability to relate, and cannot be involved in anyadditional relationships (i.e., the maximum number of relationships havealready been established). For example, a printer port of a personalcomputer is available if nothing is connected to it, andbusy/unavailable if a printer cable is plugged into it.

2.3.1 ITInterface Class

An ITInterface class inherits from ITEntity class and has the followingmethods:

-   1) ITInterface(String name, Type type)—constructor, creates an    ITInterface instance with specified name and type-   2) boolean isSingleConnection( )—returns true if this ITInterface is    a single-connection IT interface, and false otherwise-   3) boolean isAvailable([int p])—returns true if ITInterface is    available, false otherwise; optional parameter p indicates the    specific connection for a multi-connection interface-   4) setAvailable([ITInterface i])—makes ITInterface available; an    ITInterface parameter i may be specified for multi-connection IT    interfaces to indicate which of the multiple connections is to be    made available-   5) Vector establishInterface(ITInterface i [, int p])—establishes an    interface with the parameter IT interface; returns an empty Vector    if interface was established successfully, and a list of error    messages otherwise. For a multiple-connection IT interface, may be    optionally provided with the second parameter p specifying the    connection.-   6) int getAvailable( )—for multi-connection IT interfaces returns    the number of available connections; always returns zero    (unavailable) or one (available) for single-connection IT    interfaces; always returns “high integer” for multi-connection IT    interfaces with unlimited number of connections-   7) int getRelated( )—returns the number of ITInterface instances    related to this ITInterface-   8) Vector getRelatedITInterfaces( )—returns a list of zero or more    ITInterface instances related to this ITInterface-   9) Vector verifyValidity(ITInterface Y)—returns null Vector if a    connection between this IT interface instance and IT interface    instance Y would be valid—i.e., the ITInterface subclass of this    instance correlates with the ITInterface subclass of ITInterface    instance Y; returns a Vector containing error message(s) if    subclasses of X and Y do not correlate. Note that the    verifyValidity( ) method is a NOOP in the ITInterface class—each    subclass of ITInterface, with the exception of DefaultInterface,    overrides this method with the appropriate logic. Also note that an    ITInterface cannot be instantiated—only ITInterface subclasses have    practical uses.    2.3.2 ITInterface Subclasses

A number of different interfaces may exist among IT structures. Each ITstructure, by definition, includes the DefaultInterface, which is usedto establish relationships not involving real interfaces, such as“requires presence of . . . to install”. DefaultInterface supports anyrelationships.

Other ITInterface subclasses are (“correlates” in this context means“can only be related to”):

-   -   InstalledOn(<single>)—IT structure is installed using this        interface (correlates with Supports)    -   Supports({<single>|<multiple>})—IT structure(s) can be installed        on this interface (correlates with InstallsOn)    -   ConnectsTo(<connection type>, {<single>|<multiple>})—can connect        to IT structure(s) using <connection type>, correlates with        ConnectsTo        where:

-   <connection type>::={<direct>|<network>|<messaging>|<other>}    -   Invokes(<invocation type>, <single>)—can invoke IT structure        using <invocation type>, correlates with Invokable    -   Invocable(<invocation type>, {<single>|<multiple>})—can be        invoked by IT structure(s) using <invocation type>, correlates        with Invokes        where:

-   <invocation type>::={<direct>|<interrupt>|<other>}    -   Manages({<single>|<multiple>})—is managing IT structure(s),        correlates with Manageable    -   Manageable(<single>)—is managed by IT structure, correlates with        Manages        Table 3 shows valid ITInterface subclass correlations, wherein        “yes” denotes a pair of correlated IT interfaces.

TABLE 3 Interface correlations Default Installed Connects Interface OnSupports To Invokes Invocable Manages Manageable DefaultInterface yesyes yes yes yes yes yes yes InstalledOn yes yes Supports yes yesConnectsTo yes yes Invokes yes yes Invocable yes yes Manages yes yesManageable yes yesThe IT interface subclasses are summarized as follows in terms of IT1,IT2, IF1, and IF2:

-   -   IT1: IT structure 1    -   IT2: IT structure 2    -   IF1: interface of IT structure 1    -   IF2: interface of IT structure 2    -   1) Installed On: a characteristic of IF1 permitting IT1 to be        installed on IT2    -   2) Supports: a characteristic of IF2 permitting IT1 to be        installed on IT2    -   3) ConnectsTo: a characteristic of IF1 permitting IT1 to connect        to IT2    -   4) Invokes: a characteristic of IF1 permitting IT1 to invoke IT2    -   5) Invocable: a characteristic of IF2 permitting IT2 to be        invoked by IT1    -   6) Manages: a characteristic of IF1 permitting IT1 to manage IT2    -   7) Manageable: a characteristic of IF2 permitting IT2 to be        managed by IT1        Examples of IT interfaces are as follows:

-   A program is installed on a computer

-   A computer supports one or more programs to be installed on the    computer

-   Computer A connects to computer B through a network

-   Program A invokes program B

-   Program B is invocable by program A

-   Program A manages system B

-   System B is manageable by program A

In this embodiment, labor entities are associated with other entities bymeans of defaultInterface and defaultITRelationship. In anotherembodiment, a special ITInterface, laborInterface, may be defined, andused to comprise a laborRelationship to relate a labor entity to anotherentity.

2.3.3 Detailed Description of Non-Trivial Methods

2.3.3.1 SetAvailable

FIG. 5 is a flow chart, depicting the logic of setAvailable( ) method,in accordance with embodiments of the present invention. ThesetAvailable([ITInterface i]) method makes ITInterface available; anITInterface parameter i may be specified for multi-connection ITinterfaces to indicate which of the multiple connections is to be madeavailable. The setAvailable( ) method is invoked for ITInterfaceinstance X with an optional parameter ITInterface i 2401. If ITinterface instance X is a single-connection IT interface(X.isSingleConnection( ) returns true) 2402, the field interfacing Within ITInterface X is set to null 2403, and the count of IT interfaces Xis interfacing with is set to zero 2404. Note that it is theresponsibility of the invoker to ensure that the corresponding ITinterface that was interfacing with X (if any) also becomes available.

If ITInterface X is a multiple-connection IT interface 2402, processingensures that a parameter i is passed, indicating which connection out ofthe multitude to make available. If parameter i is not passed 2411, andan error is signaled 2412, and processing terminates. The mechanism ofsignaling an error may vary, depending on implementation, and mayinclude, but is not limited to, an error message, an exception, anABEND, a log and/or a trace entry.

Upon ascertaining availability of parameter i 2311, processing enters acritical section 2405. ITInterface i passed as the parameter to methodsetAvaliable( ) is located in the array of IT interfaces ITInterface Xis interfacing with 2406. If i is not found 2407, processing terminatesafter exiting a critical section 2410. If i is found 2407, the methodsets the entry in the array of IT interfaces ITInterface X isinterfacing with that corresponds to i to null 2408, decrements thecount of IT interfaces X is interfacing with 2409, and exits thecritical section 2410.

2.3.3.2 EstablishInterface

FIG. 6 is a flow chart depicting the logic of establishInterface( )method, in accordance with embodiments of the present invention. TheestablishInterface(ITInterface i [, int p]) method establishes aninterface with the parameter IT interface; returns an empty Vector ifinterface was established successfully, and a list of error messagesotherwise. The establishInterface( ) method is invoked for ITInterfaceinstance X with a parameter ITInterface Y and an optional parameterinteger p 2501.

The method starts by verifying validity of establishment of connectionbetween X′ and Y (by invoking method X.verifyValidity(Y)) 2502. Ifestablishment of connection between X and Y is invalid(X.verifyValidity(Y) returns error message(s)) 2503, methodestablishInterface( ) returns the error message(s) returned byX.verifyValidity(Y) invocation 2504 and terminates processing.

If ITInterface X is a single-connection interface 2505, but X isavailable 2506, method establishInterface( ) returns and error message2507 and terminates processing. Otherwise, if X is a single-connectioninterface 2505 and X is available 2506, a critical section is entered2508 the interfacingWith reference of ITInterface X is set to Y 2509,the count of IT interfaces X is connected with is set to one 2510, thecritical section is exited 2511, and processing completes successfully.

For a multiple-connection ITInterface X 2505, critical section isentered 2512. If the optional parameter p was specified on invocation ofmethod establishInterface( ) 2513, but p-th entry of X's array ofconnections is not null (X.isAvailable(p)=false), indicating that thep-th connection of X is unavailable 2514, an error message is stored2515, the critical section is exited 2511, and processing terminates.If, on the other hand, the p-th connection of X is available 2514, thep-th entry in X's array of connections is set to Y 2516.

If the optional parameter p was not specified on invocation of methodestablishInterface( ) 2513, an attempt is made to find an available(null) entry in X's array of connections 2519. If an available entry isfound 2521, the found entry is set to Y 2520, otherwise an error messageis stored 2522, and processing terminates after exiting the criticalsection 2511.

If a connection was established 2516 2520, if ITInterface X does notsupport an unlimited number of connections 2517, the count ofconnections of X is incremented 2518. The method establishInterface( )then exits the critical section 2511 and completes its processing.

2.4 IT Relationships

An IT Relationship is a pair of associated (established) IT interfacesbelonging to two different IT structure instances. Note that the notionof IT relationship is introduced for convenience. This notion is notabsolutely necessary for the model, since a pair of established ITinterfaces can always be considered in and of itself, but ITrelationships represent a convenient way of tracking interfacing ITstructure pairs.

A symmetric IT relationship is an IT relationship, involving ITinterfaces of identical class. Examples of a symmetric IT relationshipinclude:

-   1) IT structure A uses ConnectsTo interface to relate to IT    structure B, and IT structure B uses ConnectsTo interface to relate    to IT structure A.-   2) IT structure A uses DefaultInterface to relate to IT structure B,    and IT structure B uses DefaultInterface to relate to IT structure    A.

An asymmetric IT relationship is an IT relationship, involving ITinterfaces of different classes. As an example, IT structure AInstallsOn IT structure B, while IT structure B Supports IT structure A.

An abstract IT relationship instance is an IT relationship interfaceinstance involving at least one abstract IT interface instance.

A virtual IT relationship instance is a non-abstract IT relationshipinstance involving at least one virtual IT interface.

A real IT relationship instance is an IT relationship instance involvingonly real IT interface instances.

2.4.1 ITRelationship Class

ITRelationship class inherits from ITEntity class and has the followingmethods:

-   1) ITRelationship(String name, Type type[, ITInterface A,    B])—constructor, establishes a relationship <name> of type <type>    using IT interfaces A and B, or defaultInterface if A and B are not    specified.-   2) boolean isSymmetric( )—returns true if relationship is symmetric,    false otherwise-   3) [ ] ITInterface getRelatedITInterfaces( )—returns the pair of    ITInterface instances involved in a relationship

ITRelationship cannot be instantiated—only ITRelationship subclasseshave practical uses.

2.4.2 ITRelationship Subclasses

Subclasses of the ITRelationship class are predicated by the types of ITinterfaces included in the model. The following IT relationships mayexist given the types of IT interfaces defined above:

-   -   DefaultITRelationship—two IT structures are related in an        unidentified way    -   InstallationITRelationship—IT structure 1 is installed on IT        structure 2    -   CommunicationITRelationship(<connection type>)—IT structure 1        communicates to IT structure 2 using <connection type>    -   InvocationITRelationship(<invocation type>)—IT structure 1        invokes IT structure 2    -   ManagementITRelationship—IT structure 1 manages IT structure 2        2.5 IT Dependencies

An IT dependency is a characteristic of an ITStructure class, indicatingrequirements of this ITStructure class instances for presence or absenceof this or other ITStructure class instances.

A symmetric IT dependency is an IT dependency which can be applied toITStructure subclasses involved, regardless of the order of ITStructuresubclasses in the IT dependency predicate. For example, IT structure Adepends on IT structure B, and IT structure B depends on IT structure Ain the same way. The order of A and B in the previous sentence may bereversed without a change in meaning of the sentence.

An asymmetric IT dependency is a non-symmetric IT dependency (i.e., itcannot be applied to ITStructure subclasses involved regardless of theirorder in the IT dependency predicate). For example: IT structure Adepends on IT structure B, but IT structure B does not depend on ITstructure A.

2.5.1 ITDependency Class

ITDependency class inherits from ITEntity class and has the followingmethods:

-   1) ITDependency(String name, String A, B)—constructor, establishes a    dependency of ITStructure subclass A on ITStructure subclass B,    where A and B are names of subclasses.-   2) boolean isSymmetric( )—returns true if relationship is symmetric,    false otherwise-   3) [ ] String getDependentClasses( )—returns the pair of names of    ITStructure subclasses involved in an IT dependency.

ITDepdendency cannot be instantiated—only ITDependency subclasses havepractical uses.

2.5.2 ITDependency Subclasses

A number of different dependencies may exist among IT structurescomprising (i.e., included in a complex IT structure's composition) orpotentially comprising an IT structure (i.e., having a potential ofbeing included in a complex IT structure's composition). For thepurposes of this definition, the following dependencies (ITDependencysubclasses) are considered (i.e., other dependencies may be defined asappropriate for the structural model):

-   1) RequiresPresenceOf—as in “IT structure 1 requires presence of IT    structure 2”-   2) ExclusiveWith—Negation of 1—as in “IT structure 1 is exclusive    with IT structure 2”, IT structure 1 cannot be installed or operate    in the presence of IT structure 2

In this embodiment, no difference is made between requirement ofpresence for installation and requirement of presence for operation, andthe corresponding exclusivity. In another embodiment, such distinctioncould be made.

2.6 IT Delivery Environment

An IT delivery environment (or delivery environment) is a collection ofrules, policies, practices, and associated support functions, includinglabor, physical space, power supply, hardware, software, networking, andmanagement facilities involved in operating a data center, as well asmeans of provisioning and deployment of the aforementioned supportfunctions. IT delivery environment also includes a collection of alldelivery-bound real IT structures operating in it or in process of beingdeployed.

IT delivery environment may be null if every IT structure in it operatesindependently, does not use any data center services, no data centerinfrastructure exist, and no rules or standards are imposed on ITstructures by the delivery environment. For example: a stand-alonepersonal computer is operated in a null IT delivery environment.

A delivery-bound IT structure is a virtual IT structure that can beprovisioned and deployed in a particular IT delivery environment.

2.6.1 ITDeliveryEnvironment Class

ITDeliveryEnvironment class inherits from ITStructure and is always acomplex IT structure. ITDeliveryEnvironment composition includes all ITstructures deployed in the delivery environment. ITDeliveryEnvironmentcomposition may (and normally would) also include one or more ITstructures representing data center infrastructure.

Unlike ITStructure, ITDeliveryEnvironment permits an emptycomposition—empty composition is valid for the null IT deliveryenvironment.

In addition to the standard ITStructure methods, ITDeliveryEnvironmentincludes the following methods:

-   1) Vector verifyConformance(ITStructure A)—verifies conformance of    an IT structure to the rules of the IT delivery environments.    Returns an empty Vector if the parameter IT structure conforms to    the IT delivery environment rules, and a Vector containing a list of    error message strings if the parameter IT structure does not conform    to the IT delivery environment rules. This method is a NOOP for the    null IT delivery environment.

Example

A set of product standards may be established by a data center, suchthat for certain types of products only products included in thestandard set may be used—e.g., operating systems may be restricted toUNIX, and Windows; e.g., UNIX hardware platforms may be restricted toRS/6000 model F50 or H50 and no other computer may be used to run UNIX.verifyConformance( ) method in this case would examine the compositionof its parameter IT structure (recursively, if the parameter ITstructure is complex) and ensure that it only includes products foroperating systems and hardware platform for UNIX that are either withinthe established set of standards or have higher level of abstractionthan specific operating system and specific type of hardware.

-   2) Vector addElement({<new>|<update>}, ITStructure A)—overrides the    parent class addElement( ) method; performs delivery binding of a    virtual IT structure. Returns a Vector containing a delivery-bound    IT structure as the first element if delivery binding is successful,    and a list of error messages otherwise. This method is a NOOP (i.e.,    returns the input virtual IT structure as the first element of the    returned Vector) for the null IT delivery environment. <new> or    <update> input parameter may be specified to indicate whether this    is a binding of a newly added IT structure, or an update of an    existing IT structure.-   3) Vector deploy({<new>|<update>}, ITStructure A)—initiates    deployment of a delivery-bound IT structure. Returns a Vector    containing error messages if processing is unsuccessful, and a null    Vector otherwise. <new> or <update> input parameter may be specified    to indicate whether this is a deployment of a new IT structure, or a    change to an existing IT structure.

Note that all methods of ITDeliveryEnvironment class aresubclass-specific. Class ITDeliveryEnvironment includes NOOPplaceholders.

2.7 Extending Entity Model

The above model provides a foundation for building an IT class library.However, it is highly abstract and insufficient for effective modelingof IT. A set of general extensions, with its classes inheriting from theappropriate base IT classes, defining basic IT constructs, such ascomputers or network devices, is required as further foundation. Suchextended class libraries exist—e.g., Common Information Model (CIM).

Another example of such class hierarchy is described in FIG. 18, inaccordance with embodiments of the present invention. FIG. 18 is anexample of a set of extensions going from the class hierarchy origin(ITEntity) down to a set of specific computer models shown at a lowesthierarchical level as the virtual IT structures RS/6000 model F30,RS/6000 model F50, and RS/6000 model H50. FIG. 18 also showsintermediate hierarchical levels having successively lower degrees ofabstraction. For example, consider the following example path throughthe hierarchical representation shown in FIG. 18: ITStructure, device,Identifiable Device, computer, IBM xSreies, RS/6000, RS/6000 model F50.In the preceding example, device is less abstract than ITstructure,IdentifiableDevice is less abstract than device, computer is lessabstract than IBMxSeries, IBMxSeries is less abstract than RS/6000, andRS/6000 is less abstract than RS/6000 model F50. The lowest level ITstructure of RS/6000 model F50 is a virtual IT structural, though notdelivery bound.

The present invention discloses a translator (see Section 2.10 infra) totranslate the abstract IT structure at the highest level (denoted asITStrucure) to the virtual IT structures RS/6000 model F30, RS/6000model F50, and RS/6000 model H50. To effectuate such translation, all ofthe intermediate IT structures shown in FIG. 18 may be stepped throughin order to arrive at the final virtual IT structures (e.g., RS/6000model F30, RS/6000 model F50, RS/6000 model H50, etc.). In someembodiments, however, the designer may provide sufficient inputdescription (typically stored in libraries) so that the translator maynot have to step through all of the intermediate IT structures shown inFIG. 18 to arrive at the final virtual IT structures. For example, arequirement that a particular IT structure can store and executesoftware may imply that the particular IT structure is a computer, sothat the intermediate levels of device and IdentifiableDevice in thepreceding example path could be skipped by the translator.

Although each IT structure box in FIG. 18 is a primitive IT structure, abox appearing in the hierarchy of FIG. 15 could alternatively be acomplex IT structure. For example, a box in the hierarchy couldrepresent a client-server architecture as a complex IT structure havingprimitive elements of server and client.

2.8 Extended IT Delivery Environment

Similar to ITStructure subclasses, the ITDeliveryEnvironment class canhave subclasses, used to define various delivery environments. All ofITDeliveryEnvironment subclasses must override two methods:verifyConformance( ) and addElement( ). The verifyConformance( ) methodverifies whether a particular IT structure can be deployed and canoperate within a given instance of an ITDeliveryEnvironment subclass.The addElement( ) method performs delivery binding of an IT structure tothe IT delivery environment subclass instance if the IT structure hasbeen previously verified via verifyConformance( ) to be depoyable andoperable within the IT delivery environment defined by the giveninstance of an ITDeliveryEnvironment subclass.

While this embodiment does not attempt to enumerate all possibledelivery environments, an example ITDeliveryEnvironment subclass, calledStandardizedITEnvironment is described. The key characteristic of theStandardizedITEnvironment is that it imposes product standards andrestricts IT structures deployed and operated within it only to theallowable product set. So, the verifyConformance( ) method ofStandardizedITEnvironment checks primitive composition of its argumenttarget IT structure and indicates conformance only if every element ofthe primitive composition of the target IT structure belongs to the setof primitive IT structures permitted by the ITDeliveryEnvironmentsubclass. For example, the ITDeliveryEnvironment subclass may restrict acomputer to be an IBM xSeries computer or an IBMzSeries computer.

Anorther embodiment for using the verifyConformance( ) method is asituation in which an IT structure is currently deployed in IT deliveryenvironment A, but it is desired that this IT structure migrate to ITdelivery environment B. Accordingly, this IT structure would be checkedagainst the verifyConformance( ) method of delivery environment B todetermine if this IT structure could be deployed in delivery environmentB.

FIG. 19 is a flow chart depicting a modified addElement( ) method ofStandardizedITEnvironment to perform delivery binding of the argumenttarget IT structure to the instance of StandardizedITEnvironment, inaccordance with embodiments of the present invention. The modifiedaddElement( ) method effectuates IT delivery binding by invoking thegeneral addElement( ) method of FIG. 3 with an addition of elementsrequired to delivery bind the IT structure to a given IT deliveryenvironment. As a part of this process, the modified addElement( )method of FIG. 19 includes the general addElement( ) method 1902 of FIG.3. If at least one element of the primitive composition of thedelivery-bound IT structure requires access to the Internet, then themodified addElement( ) method assigns 1904 IP addresses to the elementsof primitive composition of the target IT structure requiring IPaddresses, these IP addresses being unique relative to the currentprimitive composition of the instance of StandardizedITEnvironment andadhering to the IP addressing policy of the instance ofStandardizedITEnvironment. Similarly, the addElement( ) method assignsnames 1906 to the elements of primitive composition of the target ITstructure requiring names, and ensures uniqueness of these namesrelative to the current primitive composition of the instance ofStandardizedITEnvironment and adherence of these names to the namingpolicies of the instance of StandardizedITEnvironment. If target ITstructure requires access to the Internet through the firewall(s)provided by the instance of StandardizedITEnvironment, the firewallrules of the instance of StandardizedITEnvironment are updated 1908 topermit the appropriate communications.

2.8.1 Verifying Conformance of an ITStructure to an Exemplary DeliveryEnvironment

The exemplary delivery environment is a data center and is aimed atproviding the highly-available branded infrastructure forInternet-accessible IT applications.

The data center is a new, state-of-the-art facility. It is built ontoday's technology and practices a philosophy of being asecurity-focused operation. Activities and services are monitored by anexperienced technical staff 24×7 from the Network Operations Center(NOC).

The facilities include 3,000 square feet of raised floor, a networkoperations monitoring center, conference rooms, administrative space andcoffee room.

The physical space of the data center has a secure co-location in a3,000 square foot room with 18″ raised floor and is ADA (Americans withDisabilities Act)-compliant. The physical space includes 27″×39″×84″cabinets with internal vertical cable management and vented front andback doors. All hardware must fit into cabinets. No space other thancabinets is provided.

The electrical power to the data center from NYSEG (New York StateElectric and Gas Company) is delivered by dual redundant feeds. Theelectric service in the building is connected to a parallel redundantUPS. There is a backup 1000 KW diesel generator with 7-day fuel reserve.

Primary internet access of the data center is via AT&T Gigabit Ethernetover multi-mode fiber to their national fiber network node located inadjacent building. This network node has eight connections to the AT&Tnetwork. Alternate internet access is via 100 Mbps Ethernet oversingle-mode fiber connection to the Cable & Wireless Network.

Security for the data center includes access control by Smart Cardsystem issued by NOC personnel staffed 24×7×365 (24 hours, 7 days aweek, 365 days a year). Data center floor access is controlled by accesscard and biometric scan. Visitors are granted access by duly authorizedrepresentatives of the data center clients. A biometric scan andsurrender of the visitor's driver's license for a proxy card is requiredfor visitors to gain access from the lobby to the administrative area.Another biometric scan and use of the access card is required to enterthe raised floor area.

Conformance factors for the IT structure to the above IT deliveryenvironment (i.e., data center) include:

-   -   Electric power availability, reliability (and possibly voltage)    -   Ability to introduce devices out of the list of “supported”        devices    -   Ability to use specific software, or requirement to run specific        software (e.g., for monitoring or virus defense)    -   Availability of specific rack sizes/space    -   Ability to use geometrically non-standard devices    -   Compliance to physical network layer (jack types; switches/hubs;        network speed)    -   Compliance to monitoring/admin access (e.g., there may be a        requirement to have an extra network interface per physical box        for admin access)    -   Possible conflict of application availability requirements to DE        service window    -   Network bandwidth requirements    -   Internet availability requirements (dual-ISP, etc. . . . )    -   Architectural requirements with respect to network (layering,        firewalls, IP addressing schema, network isolation requirements)    -   Network traffic requirements (e.g., “This IT Delivery        Environment will allow only HTTP/HTTPS traffic from the Internet        to your hosts”; “We do not allow outgoing traffic on port 25        directly, you must use one of our SMTP servers if you want to        send email”)    -   Application type limitations (“We do not allow mass-mailing        applications”)    -   Security level provided by IT Delivery Environment versus IT        structure security requirements        2.9 IT Development Process

FIG. 9 is a chart depicting the IT development process, in accordancewith embodiments of the present invention. Translator 3009 (see Sec.2.10; FIG. 10) may be used in a translation process to translate anabstract IT structure 3006 into another abstract IT structure 3007having a lower degree of abstraction than abstract IT structure 3006.This translation process may be recursively repeated until the abstractIT structure 3006/3007 has been translated into a virtual IT structure3008 or until the translation process aborts due to an unsuccessfultranslation attempt. Alternatively, a single translation of abstract ITstructure 3006 by translator 3009 may produce the virtual IT structure3008. The virtual IT structure 3008 serves as input to the deliverybinder 3012 (see Sec. 2.11; Sec. 2.2.2.5, addElement ( ) method, FIG.3), which translates the virtual IT structure into a delivery-bound ITstructure 3013, elements of which are then provisioned and deployed 3014(see Sec. 2.12; deploy( ) method), resulting in a real IT structure 3015operating in the appropriate IT delivery environment.

2.10 Translation

Translation is performed on an abstract IT structure instance with theintention of obtaining a virtual IT structure, which can then beoptimized and bound to one or more IT delivery environment to obtain oneor more real IT structure. FIGS. 10 and 11 collectively describe an ITtranslator (ITRAN) adapted to translate an abstract IT structure to thevirtual IT structure.

FIG. 10 is a flow chart depicting the process of translation of ITstructure instance X 3501, in accordance with embodiments of the presentinvention. The process starts by initializing the return Vector 3508 toan empty Vector 3502. If X is not abstract 3503, no translation isnecessary, and a null return Vector is returned to indicate that noaction was performed (and no errors occurred).

The process then performs a series of iterations until either an erroroccurs or a virtual IT structure is obtained. The process invokes thetranslation iteration process 3504, as described infra in relation toFIG. 11, to iteratively translate the abstract elements of X (i.e., theIT structures in the composition of X) until an instantiation of Xfollowing said iterative translation is virtual. If an error isindicated by the translation iteration (by returning error message(s))3505, any error messages returned by the translation iteration processare added to the return Vector 3506 and processing terminates. Iftranslation iteration processing did not indicate an error 3505, a checkis performed to ascertain whether the translation iteration processingwas successful 3507 (i.e., the translation iteration process returned anew instance of IT structure X), and if so, the new instance of ITstructure X returned by the translation iteration process is made thefirst element of the return Vector 3508, and the current instance of ITstructure X is replaced with the new instance of IT structure X returnedby the translation iteration process 3509. The process then loops backto the check of whether the instance of IT structure X is still abstract3503.

FIG. 11 is a flow chart depicting the translation iteration process,which is performed for an IT structure instance X 3601, in accordancewith embodiments of the present invention. The process iterates throughthe abstract elements of X's composition to perform a translation ofeach abstract element of X, wherein the iterations end when are-instantiation of X results in X being virtual (i.e., being in avirtual state).

The process starts by initializing the return Vector 3620 to an emptyVector 3602. The process then invokes the process of specification for X3603, which may be a NOOP if X is fully specified, or, if X is not fullyspecified, will ensure full specification of characteristics of X. If anerror occurs during the specification process for X 3604, any errormessages returned by the specification process are added to the returnVector 3605 and processing terminates.

The process then checks whether X is abstract 3606, and if X is nolonger abstract (i.e., X is now virtual), the process makes X the firstelement of the return Vector 3607 and returns.

If X is still abstract 3606, the process invokes selection of subclassesfor X 3608. If an error occurs during subclass selection 3609, any errormessages returned by the subclass selection process are added to thereturn Vector 3605 and processing terminates.

If subclass selection did not indicate an error 3609, the process checkswhether X is still abstract 3610, and if X is no longer abstract (i.e.,X is now virtual), the process makes X the first element of the returnVector 3607 and returns.

If X is still abstract 3610, the process checks whether X is primitive3611, and if so, the process places a translation error message in thereturn Vector 3607 and processing terminates. The reason for this isthat subclass selection process for a primitive IT structure hassearched all possible subclasses of X (including any existing virtual ITstructures) and has not found one that would represent a satisfactorytranslation result for X—i.e., no possible virtual IT structure existsthat would satisfy functional, operational, and other requirementsand/or constraints imposed on X.

If X is complex 3611, the process iterates through abstract elements ofX's composition 3612. Because X is still abstract, by definition ofabstract IT entities, X's composition includes at least one abstractelement. Each iteration through X's composition finds the next abstractelement E of X's composition 3613 and recursively invokes thetranslation process for E 3614. If an error occurs during translation ofE 3615, any error messages returned by the recursive invocation of thetranslation process are added to the return Vector 3605 and processingterminates.

If translation process is successful and returns a new instance of E3615, the new instance of E (denoted as E_(NEW)) is substituted for thecurrent instance of E in the composition of X 3616. The process ofsubstitution (not shown, but an analogous process is shown in FIG. 14)involves ensuring that any IT dependencies in X involving E are stillsatisfied, any IT relationships in X involving E are still valid andestablished, any characteristics of X (functional, operational, orother) are still supported, and X is still valid for any IT deliveryenvironment for which it is targeted.

X (with E_(NEW) substituted therein) is then re-instantiated 3618 toform an interim IT structure instance. If an error occurs duringre-instantiation of X 3619 (e.g., if the interim IT structure instanceis not virtual), error messages are added to the return Vector 3605 andprocessing terminates.

X (now re-instantiated) is then made the first element of the returnVector 3620. If X is no longer abstract 3621 (i.e., it is virtual), thereturn Vector (including X as its first element) is returned andprocessing terminates. If X is still abstract 3621, processing iteratesto finding the next abstract composition element of X 3612.

FIG. 12 is a flow chart depicting the process of ensuring specificationof characteristics of abstract IT structure instance X 3701, inaccordance with embodiments of the present invention. The process startsby initializing the return Vector 3707 to an empty Vector 3702. Theprocess then invokes the adjustment process for the X's function(s)3703. The adjustment process for a particular characteristic of an ITstructure may be a NOOP if that characteristic is fully specified, or,otherwise, will ensure full specification of that characteristic. If anerror occurs during the adjustment of X's function(s) 3704, any returnederror messages are added to the return Vector 3705 and processingterminates.

The process then checks whether X is still abstract 3706. It isconceivable that as a result of invocation of setFunctions( ) method ofX, X became virtual. If this is the case, X is made the first element ofthe return Vector 3707 and processing terminates.

If X is still abstract 3706, the process invokes the adjustment processfor the X's operational characteristics 3708. If an error occurs duringthe adjustment of X's operational characteristics 3709, any returnederror messages are added to the return Vector 3705 and processingterminates.

The process then once again checks whether X is still abstract 3710. Itis conceivable that as a result of invocation ofsetOperationalCharacteristics( ) method of X, X became virtual. If thisis the case, X is made the first element of the return Vector 3707 andprocessing terminates.

If X is still abstract 3710, the process invokes the adjustment processfor the X's resolution values 3711. If an error occurs during theadjustment of X's resolution values 3712, any returned error messagesare added to the return Vector 3705 and processing terminates,otherwise, the process makes X the first element of the return Vector3707 prior to completion.

FIG. 13 is a flow chart depicting the process of adjusting a particularset of characteristics of IT structure instance X 3801, in accordancewith embodiments of the present invention. The process starts byinitializing the return Vector to an empty Vector 3802. The process thenbuilds a list D of unspecified characteristics of the requested typethat have default values 3803. If D is not empty 3804 (i.e., at leastone unspecified characteristic of the requested type has a defaultvalue), the unspecified characteristics are set to their default value3805 using the appropriate method (i.e., setFunctions( ) for functionalcharacteristics, setOperationalCharacteristics( ) for operationalcharacteristics, and resolve( ) for resolution values). If an erroroccurs during the appropriate method invocations 3806 (i.e., if therequested characteristics could not be set to their correspondingdefault values), any error messages are added to the return Vector 3807and processing terminates.

If default setting for the unspecified characteristics of the requestedtype was successful 3806, X is re-instantiated 3808. If an error occursduring the attempt to re-instantiate X 3809 (i.e., there is an internallogic error in X-X has accepted the default settings for the unspecifiedcharacteristics of the requested type, but now cannot be instantiatedusing these settings), any error messages are added to the return Vector3807 and processing terminates.

The process then builds a list U of unspecified characteristics of therequested type 3810 (i.e., those that remain unspecified after anydefaults were set). If U is not empty 3811 (i.e., at least onecharacteristic of the requested type remains unspecified), the processprompts the user for specification of the unspecified characteristics ofthe requested type 3812 and sets the now specified characteristic valuesusing the appropriate method 3813. If an error occurs during theappropriate method invocations 3814 (i.e., if the requestedcharacteristics could not be set to the values specified for them by theuser), any error messages are added to the return Vector 3807 andprocessing terminates.

A number of possibilities exist as alternatives to addressing the user,comprising:

-   -   consulting an internal policy, possibly, associated with the        target IT delivery environment(s),    -   generating a value for each unspecified characteristic of the        requested type that would not violate internal logic of the        class of IT structure X,    -   ignoring the fact that a particular characteristic is        unspecified,    -   requiring the users to always provide a default value for all        characteristics of IT structures.

If setting of the user-specified values for the unspecifiedcharacteristics of the requested type was successful 3814, X isre-instantiated 3815. If an error occurs during the attempt tore-instantiate X 3816 (i.e., there is an internal logic error in X-X hasaccepted the user settings for the unspecified characteristics of therequested type, but now cannot be instantiated using these settings),any error messages are added to the return Vector 3807 and processingterminates.

The process then checks whether X was re-instantiated during precedingsteps 3817, and if so, makes the new instance of X the first element ofthe return Vector 3818, otherwise (no error has occurred, but X was notre-instantiated—this is a NOOP processing case), an empty (as originallycreated) return Vector is returned upon completion of the process.

FIG. 14 shows the process of selection a subclass of IT structure X, inaccordance with embodiments of the present invention. The instances ofIT structure X would support characteristics of the instance (abstract)of IT structure X, relationships imposed on the instance of IT structureX, dependencies of IT structure X, and be valid for the IT deliveryenvironments to which the instance of IT structure X is targeted 3901.The process starts by initializing the return Vector to an empty Vector3902. The process then finds all subclasses of the class C of X 3903(i.e., those classes in the class library that inherit from C directlyor indirectly (by inheriting from a class that inherits from C directlyor indirectly)). If no subclasses of C are found 3904, an error isindicated 3905 and processing terminates. The reason for indicating anerror is that X is abstract, and therefore must have a way to betranslated to a virtual IT structure instance. The translation processensures that X is fully specified, and therefore, no other means ofreducing abstraction than finding a less abstract class for X remain—andthat just proved to be impossible.

If at least one subclass of C was found 3904, the process iteratesthrough the list of subclasses CL of C 3906. An instance Y of subclassCL is created 3907. If an error occurs when creating an instance of CL3908, CL is ignored (although an error message may be stored in thereturn Vector, as inability to create an instance of CL indicates anerror in CL definition) and the next value of CL is taken.

If instance Y of class CL was created successfully 3908, Y's ITdependencies are verified 3909. If an error is detected by verificationof Y's IT dependencies 3910, CL is discarded and the next value of CL istaken.

The process then attempts to impose all characteristics of IT structureinstance X on Y 3911. If any characteristics of X could not be imposedon Y and an error occurred 3912, CL is discarded and the next value ofCL is taken.

If transfer of characteristics from X to Y was successful 3912, any ITrelationships of X are imposed on Y 3913. If Y cannot support all of X'sIT relationships 3914, CL is discarded and the next value of CL istaken.

If transfer of IT relationships from X to Y was successful 3914, Y isnow verified against all IT delivery environments to which X is targeted3915. If an error is indicated 3916, CL is discarded and the next valueof CL is taken.

Now that Y supports the context of X, a check is performed to determinewhether Y is abstract 3917. It is conceivable that Y was virtual fromthe beginning, or that one or a combination of the actions performed forthe transfer of X's context to Y caused Y to become virtual. The reasonthis check was not performed before this point is that until it is knownthat Y can support the context of X, Y's type is irrelevant.

If Y is virtual 3917, it is added to the list of translation candidatesD 3921, and the next value of CL is taken.

If Y is abstract 3917, a translation of Y is attempted 3918 (recursiveinvocation of the translation process). If an error occurs duringtranslation of Y or if no error occurs but Y is not translated anyway(NOOP) 3919, CL is discarded and the next value of CL is taken.

If Y was successfully translated 3919, but the result of the translationis still an abstract IT structure 3920, CL is discarded and the nextvalue of CL is taken.

Discarding a subclass of C that does not translate into a virtual ITstructure is not a necessity but a design choice. It would be equallyvalid to include the abstract IT structure Y in the list of candidates Din hopes of subsequent user intervention and manual modification ofclass source of the class CL of Y such that translation of Y to avirtual IT structure becomes possible. The design choice may be made forconciseness and minimization of complicated actions by the user.

If Y is now virtual 3920, Y is added to the list of translationcandidates D 3921 before the next CL value is taken,

Upon completion of iteration through the subclasses CL of C, if the listof translation candidates D is empty 3922 (i.e., no translationcandidates were found), an error is indicated 3905 and processingterminates.

If the list of translation candidates D contains at least onetranslation candidate 3922, the process of translation candidateselection is performed 3923, resulting in selection of a singletranslation result Y from the list of translation candidates D, which ismade the first element of the return Vector 3924 prior to completion ofthe process.

FIG. 15 is a flow chart depicting the process of selecting the besttranslation candidate Y from a list of translation candidates D (allvirtual) 30001, in accordance with embodiments of the present invention.The process starts by optimizing each element of D (using its optimize() method), and, if optimization is successful, replacing the element ofD with the result of its optimization 30006. If the list of candidates Dhas a single element 30002, no further action is performed and the oneelement of D is returned.

If the list of translation candidates D has more than one element tochoose from 30002, the prioritized list of optimization classes(getOptimizationFunctions( ) method) is retrieved 30003. The processthen iterates through the list G of optimization classes 30004, alwaystaking the next (i.e., the highest priority) optimization class F fromthe list 30005. The process then assesses each element of D using theassessment function A associated with the optimization class F 30007 andonly keeps in D the elements for which A produces the best result 30008,discarding all others.

If more than one element remains in D 30009 (i.e., optimization resultedin equally good result for multiple elements of D), the process iteratesto the next assessment function.

If after the application of a sequence of assessment functions, D onlyhas a single element 30009, that element is returned as the one selectedfor translation from the list of candidates D.

If all assessment functions are exhausted before D is reduced to asingle element 30004, the list of elements in D is presented to the userand the user's choice acts as the tie-breaker 30010—the user can selecta single element from the list and the others will be discarded prior tothe process completion.

Prompting the user for a tie-breaker decision is a design choice. Otherdesigns are possible, including those in which other means of breakingthe tie are employed (e.g., random choice), and those in which multipleelements of D are returned and, as a result, the user is presented withmultiple equally valid translations. The reason for the choice of humanintervention as the tie-breaker is the extremely low probability ofhaving multiple applications of assessment functions to multipledifferent optimized IT structure instances produce identical results.

2.11 Binding

An IT structure instance X can be added to another IT structure Y byinclusion of X into the composition of Y by means of the addElement( )method of Y. The process of addition of IT structure instance X to Y iscalled binding.

2.11.1 Delivery Binding

A virtual IT structure targeted to a particular IT delivery environmentmay be delivery-bound (i.e., translated into a delivery-bound virtual ITstructure) by means of invoking the addElement( ) method of the targetITDeliveryEnvironment class instance.

2.12 Initiating Deployment of a Delivery-Bound IT Structure

Deployment of a delivery-bound IT structure is initiated by invoking themethod deploy( ) of the particular ITDeliveryEnvironment class instance.

2.13 Fall-Back Policy

In several places above it has been noted that it is not always possibleto transition from an abstract IT structure to, eventually, a real ITstructure. A trivial cause of this may be unavailability of theappropriate materials in a provisioning system. More complex cases arepossibly, in which, although materials are available, the rightcombination of them cannot be derived, or, worse, a wrong choice wasmade in a decision tree of one of the steps of translation to makedelivery binding impossible. In many of these cases, returning to aprevious step in the IT development process may resolve the problem.Therefore, a fall-back policy is implemented throughout the ITdevelopment process, such that, should a condition be reached preventingthe production of a real IT structure as a result of a step of the ITdevelopment process, a return to the appropriate previous step of the ITdevelopment process is performed and a different decision is made,resulting hopefully in a positive outcome of the IT development process.

2.14 IT Agents

An IT agent is a program, installed on or embedded within OS of acomputer, or embedded within microcode or hardware of a device, whichgathers information about hardware configuration of a computer or adevice, software installed on a computer, and network connectivity of acomputer or a device, and transmits this information to a requester.

IT agents may transmit gathered information to a requester unsolicitedor in response to a request. IT agents possess proper OS authorizationand proper network connectivity to be able to transmit gatheredinformation.

IT agents are a particular case of software agents in general, andtherefore their implementation is OS- and possibly hardware-dependent.

External discovery functions other than agents may be used to obtainsome or all of the required information.

Depending on the degree of sophistication of an IT agent, an IT agentmay or may not be able to provide certain types of information—e.g., anIT agent may or may not contain logic permitting it to examinecustomization and configuration parameters of a particular program. Forthe purposes of this embodiment, it is assumed that an IT agent alwayspossesses the degree of sophistication required to accomplish its taskand furnish the information necessary to fulfill a particular function.If this is not the case, and some of the required information may not beprovided by an IT agent, a manual completion step may be required insome of the methods described below, enabling the user to provide themissing information.

Depending on a security policy and network connectivity of a particularIT delivery environment, some IT agents may be unable to gain access tosome of the information they intend to gather, or to transmit some ofthe gathered information. For the purposes of this embodiment, it isassumed that an IT agent always possesses the necessary authority togather the information it needs and is capable of transmitting thisinformation whenever such transmission is required. If this is not thecase, and some of the required information may not be provided by an ITagent, a manual completion step may be required in some of the methodsdescribed below, enabling the user to provide the missing information.

IT agents are assumed to be present on all computers and smart devicescomprising a real IT structure.

2.15 Reverse-Specifying an IT Structure

In order to accomplish some of the functions described below, it may benecessary to perform a process of delivery-binding “in reverse”, havingan operational configuration as input, and deriving from it a real and avirtual IT structure. The process relies on the information gathered byIT agents and builds a real IT structure first, including all ITentities within an IT structure being examined. Once a real IT structureis built, a corresponding virtual IT structure is produced by discardingthe information imposed on an IT structure by the delivery bindingprocess associated with a particular IT delivery environment, andreplacing real primitive IT structures in an IT structure compositionwith their respective virtual primitive counterparts.

While the reverse-specification process will recreate composition and ITrelationships of an IT structure, it will not produce IT dependencies orany methods beyond those present in the real or virtual primitive ITstructures and IT relationships used to comprise thereverse-specification.

The process of reverse-specification is illustrated in FIG. 16, inaccordance with embodiments of the present invention. The process startsby creating a complex IT structure R, with empty composition 31501. Theprocess proceeds to establishing reverse-specification scope 31502. Thisis necessary to bound the reverse-specification process to the necessarysubset of the IT delivery environment. The scope of reversespecification is a list of IT entities (most likely, computers)indicated by a user. If the scope is not provided, all IT entitiessupplied with agents are considered within the scope—e.g., the whole ITdelivery environment. While there are unprocessed entity collections inscope (an entity collection is a group of IT entities reachable by asingle discovery agent—e.g., a computer with its full software stack)31503, consider the next unprocessed entity collection 31504. Obtain thelist of entities and relationships from the associated discovery agent31505, and add this list to the composition of IT structure R 31506.When all the entity collections are processed 31503, if composition of Ris empty 31507, en error is indicated 31508. The resulting IT structureR is returned to the invoker 31509. The resulting IT structure R mayresult from either reverse specifying an IT delivery environment or fromreverse specifying an IT system instance.

2.16 Comparing IT Structures

In some cases, it may be advantageous to compare two IT structures. ITstructure classes can be compared by comparing their source code usingconventional means of program comparison (e.g., delta-compare utility).The process of comparing two IT structure instances is described infra.

The process of comparing IT structures assumes one of the two cases,based on the usage of results of a comparison (these are the practicalcases when a comparison would be useful—the method of comparison is notrestricted to these situations):

-   1) The IT structure instances being compared are an original and its    reverse-specification—for deployment verification and detection of    unauthorized modifications.-   2) The IT structure instances being compared are instances of the    same IT structure subclass—for testing of IT structure methods by    the user.

FIG. 17 describes the process of comparing two IT structure instances.The process obtains as input two IT structure instances, termed “old”(X) and “new” (Y) Al. The process obtains primitive compositions(getPrimitiveComposition( )) of the old 1702 and the new 1703 ITstructure instances. The process then obtains primitive relationshipslist (getPrimitiveRelationships( )) of the old 1704 and the new IT 1705structures.

The process then matches elements of the old and the new IT structureinstances primitive compositions and determines any additions ordeletions in (assumed) derivation of the new IT structure from the old1706, and reports any additions or deletions in the new IT structurerelative to the old one 1707.

The process then performs a similar matching for IT relationships of theold and the new IT structure instances 1708 and reports any differences1709.

The process then produces a report (textual and/or graphical), showingany differences, and marking them as additions or deletions.

3.0 Computer System

FIG. 20 illustrates a computer system 90 used for implementing an ITEntity Model and associated processes including any subset of thealgorithms and methods described supra, in accordance with embodimentsof the present invention. The computer system 90 comprises a processor91, an input device 92 coupled to the processor 91, an output device 93coupled to the processor 91, and memory devices 94 and 95 each coupledto the processor 91. The input device 92 may be, inter alia, a keyboard,a mouse, etc. The output device 93 may be, inter alia, a printer, aplotter, a computer screen, a magnetic tape, a removable hard disk, afloppy disk, etc. The memory devices 94 and 95 maybe, inter alia, a harddisk, a floppy disk, a magnetic tape, an optical storage such as acompact disc (CD) or a digital-video disc (DVD), a dynamic random accessmemory (DRAM), a read-only memory (ROM), etc. The memory device 95includes a computer code 97. The computer code 97 includes one or morealgorithms for implementing an IT Entity Model and associated processesincluding any subset of the algorithms and methods described supra. Theprocessor 91 executes the computer code 97. The memory device 94includes input data 96. The input data 96 includes input required by thecomputer code 97. The output device 93 displays output from the computercode 97. Either or both memory devices 94 and 95 (or one or moreadditional memory devices not shown in FIG. 20) may be used as acomputer usable medium (or a computer readable medium or a programstorage device) having a computer readable program code embodied thereinand/or having other data stored therein, wherein the computer readableprogram code comprises the computer code 97. Generally, a computerprogram product (or, alternatively, an article of manufacture) of thecomputer system 90 may comprise said computer usable medium (or saidprogram storage device).

While FIG. 20 shows the computer system 90 as a particular configurationof hardware and software, any configuration of hardware and software, aswould be known to a person of ordinary skill in the art, may be utilizedfor the purposes stated supra in conjunction with the particularcomputer system 90 of FIG. 20. For example, the memory devices 94 and 95may be portions of a single memory device rather than separate memorydevices.

While embodiments of the present invention have been described hereinfor purposes of illustration, many modifications and changes will becomeapparent to those skilled in the art. Accordingly, the appended claimsare intended to encompass all such modifications and changes as fallwithin the true spirit and scope of this invention.

What is claimed is:
 1. A method for adding an Information Technology(IT) structure A to an IT structure X having a composition, said methodcomprising: receiving a first list of all dependencies of elements inthe composition of X; after said receiving the first list, determiningthat no dependency of any element E in the composition of X in the firstlist of dependencies has an exclusion with a class Y to which A belongs;receiving a second list of all dependencies of A; after said receivingthe second list, determining that no dependency of A in the second listof dependencies has an exclusion with a class Z to which an element E inthe composition of X belongs; after said determining that no dependencyof any element E in the composition of X in the first list ofdependencies has an exclusion with a class Y to which A belongs andafter said determining that no dependency of A in the second list ofdependencies has an exclusion with a class Z to which an element E inthe composition of X belongs, ensuring that A's dependencies aresatisfied followed by adding A to X, wherein said ensuring that A'sdependencies are satisfied comprises: creating an abstract structureinstance satisfying one dependency of A's dependencies; adding theabstract structure instance to the composition of X; creating anabstract IT relationship between the abstract structure instance and A;and adding the abstract IT relationship to X, wherein X is selected fromthe group consisting of a first abstract IT structure, a first virtualIT structure, and a first real IT structure, wherein A is selected fromthe group consisting of a second abstract IT structure, a second virtualIT structure, and a second real IT structure, wherein each abstract ITstructure of the first abstract IT structure and the second abstract ITstructure comprises at least one abstract IT entity, wherein eachvirtual IT structure of the first virtual IT structure and the secondvirtual IT structure comprises at least one virtual IT entity and doesnot comprise any abstract IT entity, wherein each real IT structure ofthe first real IT structure and the second real IT structure comprisesat least one real IT entity and does not comprise any abstract IT entityand does not comprise any virtual IT entity, wherein each abstract ITentity of said at least one abstract IT entity and said any abstract ITentity comprises at least two undefined characteristics, wherein eachvirtual IT entity of said at least one virtual IT entity and said anyvirtual IT entity comprises one and only one undefined characteristic,wherein the first virtual IT structure and the second virtual ITstructure are not delivery bound and cannot be deployed in an ITdelivery environment, wherein each real IT entity of said at least onereal IT entity does not comprise any undefined characteristic and can bedeployed in the IT delivery environment.
 2. The method of claim 1,wherein prior to said receiving the first list and said receiving thesecond list, the method further comprises: ascertaining that anunsatisfied dependency exists in X; and providing A such that asubsequent addition of A to X will remove said unsatisfied dependency.3. The method of claim 1, wherein a composition of X comprises an ITstructure B prior to adding A to X, and wherein after adding A to X themethod further comprises establishing a relationship between A and B. 4.The method of claim 3, wherein a composition of X comprises one or moreinterfaces prior to adding A to X, and wherein said establishingcomprises establishing the relationship between A and B using at leastone interface of said one or more interfaces.
 5. The method of claim 3,wherein the composition of X is a primitive composition of X.
 6. Themethod of claim 3, wherein the composition of X is not a primitivecomposition of X.
 7. The method of claim 1, wherein X is the firstabstract IT structure and A is the second abstract IT structure.
 8. Themethod of claim 1, wherein X is the first abstract IT structure and A isthe second virtual IT structure.
 9. The method of claim 1, wherein X isthe first abstract IT structure and A is the second real IT structure.10. The method of claim 1, wherein X is the first virtual IT structureand A is the second abstract IT structure.
 11. The method of claim 1,wherein X is the first virtual IT structure and A is the second virtualIT structure.
 12. The method of claim 1, wherein X is the first virtualIT structure and A is the second real IT structure.
 13. The method ofclaim 1, wherein X is the first real IT structure and A is the secondabstract IT structure.
 14. The method of claim 1, wherein X is the firstreal IT structure and A is the second virtual IT structure.
 15. Themethod of claim 1, wherein X is the first real IT structure and A is thesecond real IT structure.